home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / utils / unix / unzip-5.12 / atari / atari.c < prev    next >
C/C++ Source or Header  |  1994-08-15  |  27KB  |  720 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.   atari.c
  4.  
  5.   Atari-specific routines for use with Info-ZIP's UnZip 5.1 and later.
  6.  
  7.   Contains:  readdir()
  8.              do_wild()           <-- generic enough to put in file_io.c?
  9.              mapattr()
  10.              mapname()
  11.              checkdir()
  12.              mkdir()
  13.              close_outfile()
  14.              version()
  15.  
  16.   Due to the amazing MiNT library being very, very close to BSD unix's
  17.   library, I'm using the unix.c as a base for this.  Note:  If you're not
  18.   going to compile this with the MiNT libraries (for GNU C, Turbo C, Pure C,
  19.   Lattice C, or Heat & Serve C), you're going to be in for some nasty work.
  20.   Most of the modifications in this file were made by Chris Herborth
  21.   (cherborth@semprini.waterloo-rdp.on.ca) and /should/ be marked with [cjh].
  22.  
  23.   ---------------------------------------------------------------------------*/
  24.  
  25.  
  26. #include "unzip.h"
  27. #include <dirent.h>            /* MiNTlibs has dirent [cjh] */
  28.  
  29. static int created_dir;        /* used in mapname(), checkdir() */
  30. static int renamed_fullpath;   /* ditto */
  31.  
  32. /**********************/
  33. /* Function do_wild() */   /* for porting:  dir separator; match(ignore_case) */
  34. /**********************/
  35.  
  36. char *do_wild(wildspec)
  37.     char *wildspec;         /* only used first time on a given dir */
  38. {
  39.     static DIR *dir = NULL;
  40.     static char *dirname, *wildname, matchname[FILNAMSIZ];
  41.     static int firstcall=TRUE, have_dirname, dirnamelen;
  42.     struct dirent *file;
  43.  
  44.  
  45.     /* Even when we're just returning wildspec, we *always* do so in
  46.      * matchname[]--calling routine is allowed to append four characters
  47.      * to the returned string, and wildspec may be a pointer to argv[].
  48.      */
  49.     if (firstcall) {        /* first call:  must initialize everything */
  50.         firstcall = FALSE;
  51.  
  52.         /* break the wildspec into a directory part and a wildcard filename */
  53.         if ((wildname = strrchr(wildspec, '/')) == NULL) {
  54.             dirname = ".";
  55.             dirnamelen = 1;
  56.             have_dirname = FALSE;
  57.             wildname = wildspec;
  58.         } else {
  59.             ++wildname;     /* point at character after '/' */
  60.             dirnamelen = wildname - wildspec;
  61.             if ((dirname = (char *)malloc(dirnamelen+1)) == NULL) {
  62.                 fprintf(stderr, "warning:  can't allocate wildcard buffers\n");
  63.                 strcpy(matchname, wildspec);
  64.                 return matchname;   /* but maybe filespec was not a wildcard */
  65.             }
  66.             strncpy(dirname, wildspec, dirnamelen);
  67.             dirname[dirnamelen] = '\0';   /* terminate for strcpy below */
  68.             have_dirname = TRUE;
  69.         }
  70.  
  71.         if ((dir = opendir(dirname)) != NULL) {
  72.             while ((file = readdir(dir)) != NULL) {
  73.                 if (file->d_name[0] == '.' && wildname[0] != '.')
  74.                     continue;  /* Unix:  '*' and '?' do not match leading dot */
  75.                     /* Need something here for TOS filesystem? [cjh] */
  76.                 if (match(file->d_name, wildname, 0)) {  /* 0 == case sens. */
  77.                     if (have_dirname) {
  78.                         strcpy(matchname, dirname);
  79.                         strcpy(matchname+dirnamelen, file->d_name);
  80.                     } else
  81.                         strcpy(matchname, file->d_name);
  82.                     return matchname;
  83.                 }
  84.             }
  85.             /* if we get to here directory is exhausted, so close it */
  86.             closedir(dir);
  87.             dir = NULL;
  88.         }
  89.  
  90.         /* return the raw wildspec in case that works (e.g., directory not
  91.          * searchable, but filespec was not wild and file is readable) */
  92.         strcpy(matchname, wildspec);
  93.         return matchname;
  94.     }
  95.  
  96.     /* last time through, might have failed opendir but returned raw wildspec */
  97.     if (dir == NULL) {
  98.         firstcall = TRUE;  /* nothing left to try--reset for new wildspec */
  99.         if (have_dirname)
  100.             free(dirname);
  101.         return (char *)NULL;
  102.     }
  103.  
  104.     /* If we've gotten this far, we've read and matched at least one entry
  105.      * successfully (in a previous call), so dirname has been copied into
  106.      * matchname already.
  107.      */
  108.     while ((file = readdir(dir)) != NULL)
  109.         /* May need special TOS handling here. [cjh] */
  110.         if (match(file->d_name, wildname, 0)) {   /* 0 == don't ignore case */
  111.             if (have_dirname) {
  112.                 /* strcpy(matchname, dirname); */
  113.                 strcpy(matchname+dirnamelen, file->d_name);
  114.             } else
  115.                 strcpy(matchname, file->d_name);
  116.             return matchname;
  117.         }
  118.  
  119.     closedir(dir);     /* have read at least one dir entry; nothing left */
  120.     dir = NULL;
  121.     firstcall = TRUE;  /* reset for new wildspec */
  122.     if (have_dirname)
  123.         free(dirname);
  124.     return (char *)NULL;
  125.  
  126. } /* end function do_wild() */
  127.  
  128.  
  129.  
  130.  
  131.  
  132. /**********************/
  133. /* Function mapattr() */
  134. /**********************/
  135.  
  136. int mapattr()
  137. {
  138.     ulg tmp = crec.external_file_attributes;
  139.  
  140.     switch (pInfo->hostnum) {
  141.         case UNIX_:
  142.             /* minix filesystem under MiNT on Atari [cjh] */
  143.         case VMS_:
  144.             pInfo->file_attr = (unsigned)(tmp >> 16);
  145.             return 0;
  146.         case AMIGA_:
  147.             tmp = (unsigned)(tmp>>17 & 7);   /* Amiga RWE bits */
  148.             pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp);
  149.             break;
  150.         /* all remaining cases:  expand MSDOS read-only bit into write perms */
  151.         case FS_FAT_:
  152.         case FS_HPFS_:
  153.         case FS_NTFS_:
  154.         case MAC_:
  155.         case ATARI_:             /* (used to set = 0666) */
  156.             /* TOS filesystem [cjh] */
  157.         case TOPS20_:
  158.         default:
  159.             tmp = !(tmp & 1) << 1;   /* read-only bit --> write perms bits */
  160.             pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp);
  161.             break;
  162.     } /* end switch (host-OS-created-by) */
  163.  
  164.     /* for originating systems with no concept of "group," "other," "system": */
  165.     umask( (int)(tmp=umask(0)) );    /* apply mask to expanded r/w(/x) perms */
  166.     pInfo->file_attr &= ~tmp;
  167.  
  168.     return 0;
  169.  
  170. } /* end function mapattr() */
  171.  
  172.  
  173.  
  174.  
  175.  
  176. /************************/
  177. /*  Function mapname()  */
  178. /************************/
  179.  
  180. int mapname(renamed)  /* return 0 if no error, 1 if caution (filename trunc), */
  181.     int renamed;      /* 2 if warning (skip file because dir doesn't exist), */
  182. {                     /* 3 if error (skip file), 10 if no memory (skip file) */
  183.     char pathcomp[FILNAMSIZ];   /* path-component buffer */
  184.     char *pp, *cp=NULL;         /* character pointers */
  185.     char *lastsemi = NULL;      /* pointer to last semi-colon in pathcomp */
  186.     int quote = FALSE;          /* flags */
  187.     int error = 0;
  188.     register unsigned workch;   /* hold the character being tested */
  189.  
  190.  
  191. /*---------------------------------------------------------------------------
  192.     Initialize various pointers and counters and stuff.
  193.   ---------------------------------------------------------------------------*/
  194.  
  195.     if (pInfo->vollabel)
  196.         return IZ_VOL_LABEL;    /* can't set disk volume labels in Unix */
  197.  
  198.     /* can create path as long as not just freshening, or if user told us */
  199.     create_dirs = (!fflag || renamed);
  200.  
  201.     created_dir = FALSE;        /* not yet */
  202.  
  203.     /* user gave full pathname:  don't prepend rootpath */
  204.     renamed_fullpath = (renamed && (*filename == '/'));
  205.  
  206.     if (checkdir((char *)NULL, INIT) == 10)
  207.         return 10;              /* initialize path buffer, unless no memory */
  208.  
  209.     *pathcomp = '\0';           /* initialize translation buffer */
  210.     pp = pathcomp;              /* point to translation buffer */
  211.     if (jflag)                  /* junking directories */
  212.         cp = (char *)strrchr(filename, '/');
  213.     if (cp == NULL)             /* no '/' or not junking dirs */
  214.         cp = filename;          /* point to internal zipfile-member pathname */
  215.     else
  216.         ++cp;                   /* point to start of last component of path */
  217.  
  218. /*---------------------------------------------------------------------------
  219.     Begin main loop through characters in filename.
  220.   ---------------------------------------------------